

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <erl_nif.h>
#include "opus.h"

#define FRAME_SIZE 960  // 20ms 的音频数据
#define SAMPLE_RATE 16000
#define CHANNELS 1
#define MAX_PACKET_SIZE 1276  // Opus 编码后的最大数据大小

//  gcc -fPIC -shared  -o priv/opus_nif.so priv/opus_nif.c -I/usr/include/opus -lopus
// 定义结构体保存编码器和解码器
typedef struct {
    OpusEncoder *encoder;
    OpusDecoder *decoder;
} CodecState;

// NIF 加载函数
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
    int error;
    CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
    if (!state) {
        fprintf(stderr, "memory allocation error\n");
        return -1;
    }

    // 初始化 Opus 编码器
    state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
    if (error != OPUS_OK) {
        fprintf(stderr, "encoder initialization error: %d\n", error);
        enif_free(state);
        return -1;
    }

    // 初始化 Opus 解码器
    state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
    if (error != OPUS_OK) {
        fprintf(stderr, "decoder initialization error: %d\n", error);
        opus_encoder_destroy(state->encoder);
        enif_free(state);
        return -1;
    }

    *priv_data = state;
    fprintf(stderr, "NIF initialized successfully\n");
    return 0;
}

// NIF 卸载函数
static void unload(ErlNifEnv* env, void* priv_data) {
    CodecState *state = (CodecState *)priv_data;
    if (state) {
        if (state->encoder) {
            opus_encoder_destroy(state->encoder);
        }
        if (state->decoder) {
            opus_decoder_destroy(state->decoder);
        }
        enif_free(state);
    }
}

// NIF 函数：编码 PCM 数据
static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
    if (argc != 1) {
        return enif_make_badarg(env);
    }

    ErlNifBinary pcm_bin;
    if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
        return enif_make_badarg(env);
    }

    CodecState *state = (CodecState *)enif_priv_data(env);
    if (!state || !state->encoder) {
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
    }

    if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
    }

    short *pcm = (short *)pcm_bin.data;
    int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

    unsigned char opus_data[MAX_PACKET_SIZE];
    int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
    if (encoded_size < 0) {
        fprintf(stderr, "encode error: %d\n", encoded_size);
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
    }

    ERL_NIF_TERM opus_bin;
    unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
    memcpy(encoded_data, opus_data, encoded_size);

    return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
}

// NIF 函数：解码 Opus 数据
static ERL_NIF_TERM decode_opus_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
    if (argc != 1) {
        return enif_make_badarg(env);
    }

    ErlNifBinary opus_bin;
    if (!enif_inspect_binary(env, argv[0], &opus_bin)) {
        return enif_make_badarg(env);
    }

    CodecState *state = (CodecState *)enif_priv_data(env);
    if (!state || !state->decoder) {
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "decoder_not_initialized"));
    }

    short pcm[FRAME_SIZE * CHANNELS];
    int samples_decoded = opus_decode(state->decoder, opus_bin.data, opus_bin.size, pcm, FRAME_SIZE, 0);
    if (samples_decoded < 0) {
        fprintf(stderr, "解码失败: %d\n", samples_decoded);
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, samples_decoded));
    }

    ERL_NIF_TERM pcm_bin;
    unsigned char *pcm_data = enif_make_new_binary(env, samples_decoded * CHANNELS * sizeof(short), &pcm_bin);
    memcpy(pcm_data, pcm, samples_decoded * CHANNELS * sizeof(short));

    return enif_make_tuple2(env, enif_make_atom(env, "ok"), pcm_bin);
}

// NIF 函数表
static ErlNifFunc nif_funcs[] = {
    {"encode_pcm_data", 1, encode_pcm_data},
    {"decode_opus_data", 1, decode_opus_data}
};

// NIF 模块初始化
ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)



// #include <stdio.h>
// #include <stdlib.h>
// #include <unistd.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define FRAME_SIZE 960  // 20ms 的音频数据
// #define SAMPLE_RATE 16000
// #define CHANNELS 2
// #define BUFFER_SIZE 2048  // 增加缓冲区大小

// // NIF 接口函数
// static int decode_opus_data(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     OpusDecoder *decoder;
//     int error;
//     short pcm[FRAME_SIZE * CHANNELS];
//     unsigned char buffer[BUFFER_SIZE];
//     int samples_decoded;

//     decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         return -1;
//     }

//     while (1) {
//         size_t bytes_read = read(0, buffer, sizeof(buffer));  // 从 stdin 读取 Opus 数据
//         if (bytes_read == 0) break;

//         size_t bytes_processed = 0;
//         while (bytes_processed < bytes_read) {
//             size_t chunk_size = bytes_read - bytes_processed;
//             if (chunk_size > FRAME_SIZE) chunk_size = FRAME_SIZE;

//             samples_decoded = opus_decode(decoder, buffer + bytes_processed, chunk_size, pcm, FRAME_SIZE, 0);
//             if (samples_decoded < 0) {
//                 fprintf(stderr, "解码失败: %d\n", samples_decoded);
//                 // 可以选择跳过错误帧或进行错误恢复
//                 break;
//             }

//             write(1, pcm, samples_decoded * CHANNELS * sizeof(short));  // 将 PCM 数据写入 stdout
//             bytes_processed += chunk_size;
//         }
//     }

//     opus_decoder_destroy(decoder);
//     return 0;
// }

// static ErlNifFunc nif_funcs[] = {
//     {"decode_opus_data", 0, decode_opus_data}
// };

// ERL_NIF_INIT(Elixir.OpusNif, nif_funcs, NULL, NULL, NULL, NULL)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include "opus.h"
// #include <string.h>
// #define FRAME_SIZE 960  // 20ms 的音频数据
// #define SAMPLE_RATE 16000
// #define CHANNELS 2

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     OpusDecoder *decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         return -1;
//     }
//     *priv_data = decoder;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     OpusDecoder *decoder = (OpusDecoder *)priv_data;
//     if (decoder) {
//         opus_decoder_destroy(decoder);
//     }
// }

// // NIF 函数实现
// static ERL_NIF_TERM decode_opus_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary opus_bin;
//     if (!enif_inspect_binary(env, argv[0], &opus_bin)) {
//         return enif_make_badarg(env);
//     }

//     OpusDecoder *decoder = (OpusDecoder *)enif_priv_data(env);
//     if (!decoder) {
//         return enif_make_atom(env, "error");
//     }

//     short pcm[FRAME_SIZE * CHANNELS];
//     int samples_decoded = opus_decode(decoder, opus_bin.data, opus_bin.size, pcm, FRAME_SIZE, 0);
//     if (samples_decoded < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, samples_decoded));
//     }

//     ERL_NIF_TERM pcm_bin;
//     unsigned char *pcm_data = enif_make_new_binary(env, samples_decoded * CHANNELS * sizeof(short), &pcm_bin);
//     memcpy(pcm_data, pcm, samples_decoded * CHANNELS * sizeof(short));

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), pcm_bin);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"decode_opus_data", 1, decode_opus_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define FRAME_SIZE 960  // 20ms 的音频数据
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276  // Opus 编码后的最大数据大小

// // 定义结构体保存编码器和解码器
// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     // 初始化 Opus 编码器
//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     // 初始化 Opus 解码器
//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         if (state->decoder) {
//             opus_decoder_destroy(state->decoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：解码 Opus 数据
// static ERL_NIF_TERM decode_opus_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary opus_bin;
//     if (!enif_inspect_binary(env, argv[0], &opus_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->decoder) {
//         return enif_make_atom(env, "error");
//     }

//     short pcm[FRAME_SIZE * CHANNELS];
//     int samples_decoded = opus_decode(state->decoder, opus_bin.data, opus_bin.size, pcm, FRAME_SIZE, 0);
//     if (samples_decoded < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, samples_decoded));
//     }

//     ERL_NIF_TERM pcm_bin;
//     unsigned char *pcm_data = enif_make_new_binary(env, samples_decoded * CHANNELS * sizeof(short), &pcm_bin);
//     memcpy(pcm_data, pcm, samples_decoded * CHANNELS * sizeof(short));

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), pcm_bin);
// }

// // NIF 函数：编码 PCM 数据
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_atom(env, "error");
//     }

//     // 确保 PCM 数据大小正确
//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"decode_opus_data", 1, decode_opus_data},
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define FRAME_SIZE 960  // 20ms 的音频数据
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276  // Opus 编码后的最大数据大小

// // 定义结构体保存编码器和解码器
// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     // 初始化 Opus 编码器
//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_AUDIO, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     // 初始化 Opus 解码器
//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         if (state->decoder) {
//             opus_decoder_destroy(state->decoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：解码 Opus 数据
// static ERL_NIF_TERM decode_opus_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary opus_bin;
//     if (!enif_inspect_binary(env, argv[0], &opus_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->decoder) {
//         return enif_make_atom(env, "error");
//     }

//     short pcm[FRAME_SIZE * CHANNELS];
//     int samples_decoded = opus_decode(state->decoder, opus_bin.data, opus_bin.size, pcm, FRAME_SIZE, 0);
//     if (samples_decoded < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, samples_decoded));
//     }

//     ERL_NIF_TERM pcm_bin;
//     unsigned char *pcm_data = enif_make_new_binary(env, samples_decoded * CHANNELS * sizeof(short), &pcm_bin);
//     memcpy(pcm_data, pcm, samples_decoded * CHANNELS * sizeof(short));

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), pcm_bin);
// }


// NIF 函数：编码 PCM 数据
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_atom(env, "error");
//     }

//     // 确保 PCM 数据大小正确
//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"decode_opus_data", 1, decode_opus_data},
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <unistd.h>
// #include <erl_nif.h>
// #include "opus.h"
// #include <string.h>
// #define FRAME_SIZE 960  // 20ms 的音频数据
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276  // Opus 编码后的最大数据大小

// // 定义结构体保存编码器和解码器
// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     // 初始化 Opus 编码器
//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     // 初始化 Opus 解码器
//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         if (state->decoder) {
//             opus_decoder_destroy(state->decoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：从标准输入读取 PCM 数据并编码为 Opus 格式
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 0) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     short pcm[FRAME_SIZE * CHANNELS];
//     unsigned char opus_data[MAX_PACKET_SIZE];

//     // 从标准输入读取 PCM 数据
//     ssize_t bytes_read = read(STDIN_FILENO, pcm, sizeof(pcm));
//     if (bytes_read < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "read_failed"));
//     }

//     // 检查读取的数据大小是否正确
//     if (bytes_read % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     int frame_count = bytes_read / (CHANNELS * sizeof(short));

//     // 编码 PCM 数据为 Opus 格式
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     // 将编码后的 Opus 数据返回给 Elixir
//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define SAMPLE_RATE 16000  // 16 kHz
// #define FRAME_SIZE 960     // 20ms 的音频数据
// #define CHANNELS 1         // 单声道
// #define MAX_PACKET_SIZE 1276  // Opus 数据包的最大大小

// typedef struct {
//     OpusEncoder *encoder;
// } EncoderState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     EncoderState *state = (EncoderState *)enif_alloc(sizeof(EncoderState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_AUDIO, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     EncoderState *state = (EncoderState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：编码 PCM 数据
// // static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
// //     if (argc != 1) {
// //         return enif_make_badarg(env);
// //     }

// //     ErlNifBinary pcm_bin;
// //     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
// //         return enif_make_badarg(env);
// //     }

// //     EncoderState *state = (EncoderState *)enif_priv_data(env);
// //     if (!state || !state->encoder) {
// //         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
// //     }

// //     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
// //         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
// //     }

// //     short *pcm = (short *)pcm_bin.data;
// //     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

// //     unsigned char opus_data[MAX_PACKET_SIZE];
// //     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
// //     if (encoded_size < 0) {
// //         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
// //     }

// //     ERL_NIF_TERM opus_bin;
// //     if (!enif_alloc_binary(encoded_size, &opus_bin)) {
// //         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "memory_allocation_failed"));
// //     }

// //     memcpy(opus_bin.data, opus_data, encoded_size);
// //     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// // }

// // NIF 函数：编码 PCM 数据
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     EncoderState *state = (EncoderState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define SAMPLE_RATE 16000  // 16 kHz
// #define FRAME_SIZE 960     // 20ms 的音频数据
// #define CHANNELS 1         // 单声道
// #define MAX_PACKET_SIZE 1276  // Opus 数据包的最大大小

// typedef struct {
//     OpusEncoder *encoder;
// } EncoderState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     EncoderState *state = (EncoderState *)enif_alloc(sizeof(EncoderState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_AUDIO, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     EncoderState *state = (EncoderState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：编码 PCM 数据
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     EncoderState *state = (EncoderState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ErlNifBinary opus_bin;
//     if (!enif_alloc_binary(env, encoded_size, &opus_bin)) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "memory_allocation_failed"));
//     }

//     memcpy(opus_bin.data, opus_data, encoded_size);
//     ERL_NIF_TERM result = enif_make_binary(env, &opus_bin);
//     enif_release_binary(opus_bin);  // 释放分配的内存
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), result);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.OpusNif, nif_funcs, load, NULL, NULL, unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>
// #include "opus.h"

// #define SAMPLE_RATE 16000  // 16 kHz
// #define FRAME_SIZE 960     // 20ms 的音频数据
// #define CHANNELS 1         // 单声道
// #define MAX_PACKET_SIZE 1276  // Opus 数据包的最大大小

// typedef struct {
//     OpusEncoder *encoder;
// } EncoderState;

// // NIF 加载函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     EncoderState *state = (EncoderState *)enif_alloc(sizeof(EncoderState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_AUDIO, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
//     EncoderState *state = (EncoderState *)priv_data;
//     if (state) {
//         if (state->encoder) {
//             opus_encoder_destroy(state->encoder);
//         }
//         enif_free(state);
//     }
// }

// // NIF 函数：编码 PCM 数据
// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     EncoderState *state = (EncoderState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ErlNifBinary opus_bin;
//     if (!enif_alloc_binary(env, encoded_size, &opus_bin)) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "memory_allocation_failed"));
//     }

//     memcpy(opus_bin.data, opus_data, encoded_size);
//     ERL_NIF_TERM result = enif_make_binary(env, &opus_bin);
//     enif_release_binary(&opus_bin);  // 释放分配的内存
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), result);
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// // NIF 模块初始化
// ERL_NIF_INIT(Elixir.OpusNif, nif_funcs, load, NULL, NULL, unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) return -1;

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) return -1;

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) return -1;

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) return -1;

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 24000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
    
//     if (encoded_size < 0) {
//         fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 10240

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
//     unsigned char *buffer;
//     size_t buffer_size;
//     size_t buffer_used;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer = (unsigned char *)enif_alloc(MAX_PACKET_SIZE);
//     if (!state->buffer) {
//         fprintf(stderr, "Failed to allocate memory for buffer\n");
//         opus_encoder_destroy(state->encoder);
//         opus_decoder_destroy(state->decoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer_size = MAX_PACKET_SIZE;
//     state->buffer_used = 0;

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         if (state->buffer) enif_free(state->buffer);
//         enif_free(state);
//     }
// }

// static void add_to_buffer(CodecState *state, const unsigned char *data, size_t size) {
//     if (state->buffer_used + size > state->buffer_size) {
//         fprintf(stderr, "Buffer overflow\n");
//         return;
//     }
//     memcpy(state->buffer + state->buffer_used, data, size);
//     state->buffer_used += size;
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     add_to_buffer(state, (unsigned char *)pcm_bin.data, pcm_bin.size);

//     while (state->buffer_used >= FRAME_SIZE * CHANNELS * sizeof(short)) {
//         short *pcm = (short *)state->buffer;
//         int frame_count = FRAME_SIZE;

//         unsigned char opus_data[MAX_PACKET_SIZE];
//         int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//         if (encoded_size < 0) {
//             fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//             return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//         }

//         ERL_NIF_TERM opus_bin;
//         unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//         memcpy(encoded_data, opus_data, encoded_size);

//         // Move the remaining data to the beginning of the buffer
//         memmove(state->buffer, state->buffer + FRAME_SIZE * CHANNELS * sizeof(short), state->buffer_used - FRAME_SIZE * CHANNELS * sizeof(short));
//         state->buffer_used -= FRAME_SIZE * CHANNELS * sizeof(short);

//         return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
//     }

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "no_data"));
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
//     unsigned char *buffer;
//     size_t buffer_size;
//     size_t buffer_used;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer = (unsigned char *)enif_alloc(MAX_PACKET_SIZE);
//     if (!state->buffer) {
//         fprintf(stderr, "Failed to allocate memory for buffer\n");
//         opus_encoder_destroy(state->encoder);
//         opus_decoder_destroy(state->decoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer_size = MAX_PACKET_SIZE;
//     state->buffer_used = 0;

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         if (state->buffer) enif_free(state->buffer);
//         enif_free(state);
//     }
// }

// static void add_to_buffer(CodecState *state, const unsigned char *data, size_t size) {
//     if (state->buffer_used + size > state->buffer_size) {
//         fprintf(stderr, "Buffer overflow\n");
//         return;
//     }
//     memcpy(state->buffer + state->buffer_used, data, size);
//     state->buffer_used += size;
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     add_to_buffer(state, (unsigned char *)pcm_bin.data, pcm_bin.size);

//     while (state->buffer_used >= FRAME_SIZE * CHANNELS * sizeof(short)) {
//         short *pcm = (short *)state->buffer;
//         int frame_count = FRAME_SIZE;

//         unsigned char opus_data[MAX_PACKET_SIZE];
//         int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//         if (encoded_size < 0) {
//             fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//             return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//         }

//         ERL_NIF_TERM opus_bin;
//         unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//         memcpy(encoded_data, opus_data, encoded_size);

//         // Move the remaining data to the beginning of the buffer
//         memmove(state->buffer, state->buffer + FRAME_SIZE * CHANNELS * sizeof(short), state->buffer_used - FRAME_SIZE * CHANNELS * sizeof(short));
//         state->buffer_used -= FRAME_SIZE * CHANNELS * sizeof(short);

//         return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
//     }

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "no_data"));
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)



// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
//     unsigned char *buffer;
//     size_t buffer_size;
//     size_t buffer_used;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer = (unsigned char *)enif_alloc(MAX_PACKET_SIZE);
//     if (!state->buffer) {
//         fprintf(stderr, "Failed to allocate memory for buffer\n");
//         opus_encoder_destroy(state->encoder);
//         opus_decoder_destroy(state->decoder);
//         enif_free(state);
//         return -1;
//     }

//     state->buffer_size = MAX_PACKET_SIZE;
//     state->buffer_used = 0;

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         if (state->buffer) enif_free(state->buffer);
//         enif_free(state);
//     }
// }

// static void add_to_buffer(CodecState *state, const unsigned char *data, size_t size) {
//     if (state->buffer_used + size > state->buffer_size) {
//         fprintf(stderr, "Buffer overflow\n");
//         return;
//     }
//     memcpy(state->buffer + state->buffer_used, data, size);
//     state->buffer_used += size;
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     add_to_buffer(state, (unsigned char *)pcm_bin.data, pcm_bin.size);

//     ERL_NIF_TERM result = enif_make_atom(env, "no_data");

//     while (state->buffer_used >= FRAME_SIZE * CHANNELS * sizeof(short)) {
//         short *pcm = (short *)state->buffer;
//         int frame_count = FRAME_SIZE;

//         unsigned char opus_data[MAX_PACKET_SIZE];
//         int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//         if (encoded_size < 0) {
//             fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//             return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//         }

//         ERL_NIF_TERM opus_bin;
//         unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//         memcpy(encoded_data, opus_data, encoded_size);

//         result = enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);

//         // Move the remaining data to the beginning of the buffer
//         memmove(state->buffer, state->buffer + FRAME_SIZE * CHANNELS * sizeof(short), state->buffer_used - FRAME_SIZE * CHANNELS * sizeof(short));
//         state->buffer_used -= FRAME_SIZE * CHANNELS * sizeof(short);
//     }

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), result);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include "opus.h"
// #include <string.h>
// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1276

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "内存分配失败\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "编码器初始化失败: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "解码器初始化失败: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     fprintf(stderr, "NIF 初始化成功\n");
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         fprintf(stderr, "编码失败: %d\n", encoded_size);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <stdio.h>
// #include <stdlib.h>
// #include <erl_nif.h>
// #include <string.h>
// #include "opus.h"

// #define FRAME_SIZE 960
// #define SAMPLE_RATE 16000
// #define CHANNELS 1
// #define MAX_PACKET_SIZE 1920

// typedef struct {
//     OpusEncoder *encoder;
//     OpusDecoder *decoder;
// } CodecState;

// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     int error;
//     CodecState *state = (CodecState *)enif_alloc(sizeof(CodecState));
//     if (!state) {
//         fprintf(stderr, "Failed to allocate memory for CodecState\n");
//         return -1;
//     }

//     state->encoder = opus_encoder_create(SAMPLE_RATE, CHANNELS, OPUS_APPLICATION_VOIP, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus encoder: %d\n", error);
//         enif_free(state);
//         return -1;
//     }

//     state->decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &error);
//     if (error != OPUS_OK) {
//         fprintf(stderr, "Failed to create Opus decoder: %d\n", error);
//         opus_encoder_destroy(state->encoder);
//         enif_free(state);
//         return -1;
//     }

//     *priv_data = state;
//     return 0;
// }

// static void unload(ErlNifEnv* env, void* priv_data) {
//     CodecState *state = (CodecState *)priv_data;
//     if (state) {
//         if (state->encoder) opus_encoder_destroy(state->encoder);
//         if (state->decoder) opus_decoder_destroy(state->decoder);
//         enif_free(state);
//     }
// }

// static ERL_NIF_TERM encode_pcm_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     if (argc != 1) {
//         fprintf(stderr, "encode_pcm_data: Invalid number of arguments\n");
//         return enif_make_badarg(env);
//     }

//     ErlNifBinary pcm_bin;
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         fprintf(stderr, "encode_pcm_data: Invalid binary argument\n");
//         return enif_make_badarg(env);
//     }

//     CodecState *state = (CodecState *)enif_priv_data(env);
//     if (!state || !state->encoder) {
//         fprintf(stderr, "encode_pcm_data: Encoder not initialized\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "encoder_not_initialized"));
//     }

//     if (pcm_bin.size % (CHANNELS * sizeof(short)) != 0) {
//         fprintf(stderr, "encode_pcm_data: Invalid PCM size\n");
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "invalid_pcm_size"));
//     }

//     short *pcm = (short *)pcm_bin.data;
//     int frame_count = pcm_bin.size / (CHANNELS * sizeof(short));

//     unsigned char opus_data[MAX_PACKET_SIZE];
//     int encoded_size = opus_encode(state->encoder, pcm, frame_count, opus_data, MAX_PACKET_SIZE);
//     if (encoded_size < 0) {
//         fprintf(stderr, "encode_pcm_data: Opus encoding failed: %d\n", encoded_size);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, encoded_size));
//     }

//     ERL_NIF_TERM opus_bin;
//     unsigned char *encoded_data = enif_make_new_binary(env, encoded_size, &opus_bin);
//     memcpy(encoded_data, opus_data, encoded_size);

//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), opus_bin);
// }

// static ErlNifFunc nif_funcs[] = {
//     {"encode_pcm_data", 1, encode_pcm_data}
// };

// ERL_NIF_INIT(Elixir.SockWorkstation.OpusNif, nif_funcs, &load, NULL, NULL, &unload)
